include/xdk/rtlfuncs.h

   1 /******************************************************************************
   2  *                         Runtime Library Functions                          *
   3  ******************************************************************************/
   4
   5 $if (_WDMDDK_)
   6 FORCEINLINE
   7 VOID
   8 InitializeListHead(
   9   OUT PLIST_ENTRY ListHead)
  10 {
  11   ListHead->Flink = ListHead->Blink = ListHead;
  12 }
  13
  14 FORCEINLINE
  15 VOID
  16 InsertHeadList(
  17   IN OUT PLIST_ENTRY  ListHead,
  18   IN OUT PLIST_ENTRY  Entry)
  19 {
  20   PLIST_ENTRY OldFlink;
  21   OldFlink = ListHead->Flink;
  22   Entry->Flink = OldFlink;
  23   Entry->Blink = ListHead;
  24   OldFlink->Blink = Entry;
  25   ListHead->Flink = Entry;
  26 }
  27
  28 FORCEINLINE
  29 VOID
  30 InsertTailList(
  31   IN OUT PLIST_ENTRY  ListHead,
  32   IN OUT PLIST_ENTRY  Entry)
  33 {
  34   PLIST_ENTRY OldBlink;
  35   OldBlink = ListHead->Blink;
  36   Entry->Flink = ListHead;
  37   Entry->Blink = OldBlink;
  38   OldBlink->Flink = Entry;
  39   ListHead->Blink = Entry;
  40 }
  41
  42 BOOLEAN
  43 FORCEINLINE
  44 IsListEmpty(
  45   IN CONST LIST_ENTRY * ListHead)
  46 {
  47   return (BOOLEAN)(ListHead->Flink == ListHead);
  48 }
  49
  50 FORCEINLINE
  51 PSINGLE_LIST_ENTRY
  52 PopEntryList(
  53   IN OUT PSINGLE_LIST_ENTRY ListHead)
  54 {
  55   PSINGLE_LIST_ENTRY FirstEntry;
  56   FirstEntry = ListHead->Next;
  57   if (FirstEntry != NULL) {
  58     ListHead->Next = FirstEntry->Next;
  59   }
  60   return FirstEntry;
  61 }
  62
  63 FORCEINLINE
  64 VOID
  65 PushEntryList(
  66   IN OUT PSINGLE_LIST_ENTRY ListHead,
  67   IN OUT PSINGLE_LIST_ENTRY Entry)
  68 {
  69   Entry->Next = ListHead->Next;
  70   ListHead->Next = Entry;
  71 }
  72
  73 FORCEINLINE
  74 BOOLEAN
  75 RemoveEntryList(
  76   IN PLIST_ENTRY  Entry)
  77 {
  78   PLIST_ENTRY OldFlink;
  79   PLIST_ENTRY OldBlink;
  80
  81   OldFlink = Entry->Flink;
  82   OldBlink = Entry->Blink;
  83   OldFlink->Blink = OldBlink;
  84   OldBlink->Flink = OldFlink;
  85   return (BOOLEAN)(OldFlink == OldBlink);
  86 }
  87
  88 FORCEINLINE
  89 PLIST_ENTRY
  90 RemoveHeadList(
  91   IN OUT PLIST_ENTRY  ListHead)
  92 {
  93   PLIST_ENTRY Flink;
  94   PLIST_ENTRY Entry;
  95
  96   Entry = ListHead->Flink;
  97   Flink = Entry->Flink;
  98   ListHead->Flink = Flink;
  99   Flink->Blink = ListHead;
 100   return Entry;
 101 }
 102
 103 FORCEINLINE
 104 PLIST_ENTRY
 105 RemoveTailList(
 106   IN OUT PLIST_ENTRY  ListHead)
 107 {
 108   PLIST_ENTRY Blink;
 109   PLIST_ENTRY Entry;
 110
 111   Entry = ListHead->Blink;
 112   Blink = Entry->Blink;
 113   ListHead->Blink = Blink;
 114   Blink->Flink = ListHead;
 115   return Entry;
 116 }
 117
 118 NTSYSAPI
 119 VOID
 120 NTAPI
 121 RtlAssert(
 122     IN PVOID FailedAssertion,
 123     IN PVOID FileName,
 124     IN ULONG LineNumber,
 125     IN PSTR Message);
 126
 127 /* VOID
 128  * RtlCopyMemory(
 129  *     IN VOID UNALIGNED *Destination,
 130  *     IN CONST VOID UNALIGNED *Source,
 131  *     IN SIZE_T Length)
 132  */
 133 #define RtlCopyMemory(Destination, Source, Length) \
 134     memcpy(Destination, Source, Length)
 135
 136 #define RtlCopyBytes RtlCopyMemory
 137
 138 #if defined(_M_AMD64)
 139 NTSYSAPI
 140 VOID
 141 NTAPI
 142 RtlCopyMemoryNonTemporal(
 143     VOID UNALIGNED *Destination,
 144     CONST VOID UNALIGNED *Source,
 145     SIZE_T Length);
 146 #else
 147 #define RtlCopyMemoryNonTemporal RtlCopyMemory
 148 #endif
 149
 150 /* BOOLEAN
 151  * RtlEqualLuid(
 152  *     IN PLUID Luid1,
 153  *     IN PLUID Luid2)
 154  */
 155 #define RtlEqualLuid(Luid1, Luid2) \
 156     (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
 157
 158 /* ULONG
 159  * RtlEqualMemory(
 160  *     IN VOID UNALIGNED *Destination,
 161  *     IN CONST VOID UNALIGNED *Source,
 162  *     IN SIZE_T Length)
 163  */
 164 #define RtlEqualMemory(Destination, Source, Length) \
 165     (!memcmp(Destination, Source, Length))
 166
 167 /* VOID
 168  * RtlFillMemory(
 169  *     IN VOID UNALIGNED *Destination,
 170  *     IN SIZE_T Length,
 171  *     IN UCHAR Fill)
 172  */
 173 #define RtlFillMemory(Destination, Length, Fill) \
 174     memset(Destination, Fill, Length)
 175
 176 #define RtlFillBytes RtlFillMemory
 177
 178 NTSYSAPI
 179 VOID
 180 NTAPI
 181 RtlFreeUnicodeString(
 182     IN OUT PUNICODE_STRING UnicodeString);
 183
 184 NTSYSAPI
 185 NTSTATUS
 186 NTAPI
 187 RtlGUIDFromString(
 188     IN PUNICODE_STRING GuidString,
 189     OUT GUID *Guid);
 190
 191 NTSYSAPI
 192 VOID
 193 NTAPI
 194 RtlInitUnicodeString(
 195     IN OUT PUNICODE_STRING DestinationString,
 196     IN PCWSTR SourceString OPTIONAL);
 197
 198 /* VOID
 199  * RtlMoveMemory(
 200  *    IN VOID UNALIGNED *Destination,
 201  *    IN CONST VOID UNALIGNED *Source,
 202  *    IN SIZE_T Length)
 203  */
 204 #define RtlMoveMemory(Destination, Source, Length) \
 205     memmove(Destination, Source, Length)
 206
 207 NTSYSAPI
 208 NTSTATUS
 209 NTAPI
 210 RtlStringFromGUID(
 211     IN REFGUID Guid,
 212     OUT PUNICODE_STRING GuidString);
 213
 214 /* VOID
 215  * RtlZeroMemory(
 216  *     IN VOID UNALIGNED *Destination,
 217  *     IN SIZE_T Length)
 218  */
 219 #define RtlZeroMemory(Destination, Length) \
 220     memset(Destination, 0, Length)
 221
 222 #define RtlZeroBytes RtlZeroMemory
 223
 224 $endif
 225 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 226
 227 $if (_NTIFS_)
 228 NTSYSAPI
 229 PVOID
 230 NTAPI
 231 RtlAllocateHeap(
 232   IN HANDLE HeapHandle,
 233   IN ULONG Flags OPTIONAL,
 234   IN SIZE_T Size);
 235
 236 NTSYSAPI
 237 BOOLEAN
 238 NTAPI
 239 RtlFreeHeap(
 240   IN PVOID HeapHandle,
 241   IN ULONG Flags OPTIONAL,
 242   IN PVOID BaseAddress);
 243
 244 $endif
 245 $if (_WDMDDK_)
 246 NTSYSAPI
 247 BOOLEAN
 248 NTAPI
 249 RtlAreBitsClear(
 250     IN PRTL_BITMAP BitMapHeader,
 251     IN ULONG StartingIndex,
 252     IN ULONG Length);
 253
 254 NTSYSAPI
 255 BOOLEAN
 256 NTAPI
 257 RtlAreBitsSet(
 258     IN PRTL_BITMAP BitMapHeader,
 259     IN ULONG StartingIndex,
 260     IN ULONG Length);
 261
 262 NTSYSAPI
 263 NTSTATUS
 264 NTAPI
 265 RtlAnsiStringToUnicodeString(
 266     IN OUT PUNICODE_STRING DestinationString,
 267     IN PANSI_STRING SourceString,
 268     IN BOOLEAN AllocateDestinationString);
 269
 270 NTSYSAPI
 271 ULONG
 272 NTAPI
 273 RtlxAnsiStringToUnicodeSize(
 274     IN PCANSI_STRING AnsiString);
 275
 276 #define RtlAnsiStringToUnicodeSize(String) (               \
 277   NLS_MB_CODE_PAGE_TAG ?                                   \
 278   RtlxAnsiStringToUnicodeSize(String) :                    \
 279   ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
 280 )
 281
 282 NTSYSAPI
 283 NTSTATUS
 284 NTAPI
 285 RtlAppendUnicodeStringToString(
 286     IN OUT PUNICODE_STRING Destination,
 287     IN PCUNICODE_STRING Source);
 288
 289 NTSYSAPI
 290 NTSTATUS
 291 NTAPI
 292 RtlAppendUnicodeToString(
 293     IN OUT PUNICODE_STRING Destination,
 294     IN PCWSTR Source);
 295
 296 NTSYSAPI
 297 NTSTATUS
 298 NTAPI
 299 RtlCheckRegistryKey(
 300     IN ULONG RelativeTo,
 301     IN PWSTR Path);
 302
 303 NTSYSAPI
 304 VOID
 305 NTAPI
 306 RtlClearAllBits(
 307     IN PRTL_BITMAP BitMapHeader);
 308
 309 NTSYSAPI
 310 VOID
 311 NTAPI
 312 RtlClearBits(
 313     IN PRTL_BITMAP BitMapHeader,
 314     IN ULONG StartingIndex,
 315     IN ULONG NumberToClear);
 316
 317 NTSYSAPI
 318 SIZE_T
 319 NTAPI
 320 RtlCompareMemory(
 321     IN CONST VOID *Source1,
 322     IN CONST VOID *Source2,
 323     IN SIZE_T Length);
 324
 325 NTSYSAPI
 326 LONG
 327 NTAPI
 328 RtlCompareUnicodeString(
 329     IN PCUNICODE_STRING String1,
 330     IN PCUNICODE_STRING String2,
 331     IN BOOLEAN CaseInSensitive);
 332
 333 NTSYSAPI
 334 LONG
 335 NTAPI
 336 RtlCompareUnicodeStrings(
 337     IN PCWCH String1,
 338     IN SIZE_T String1Length,
 339     IN PCWCH String2,
 340     IN SIZE_T String2Length,
 341     IN BOOLEAN CaseInSensitive);
 342
 343 NTSYSAPI
 344 VOID
 345 NTAPI
 346 RtlCopyUnicodeString(
 347   IN OUT PUNICODE_STRING  DestinationString,
 348   IN PCUNICODE_STRING  SourceString);
 349
 350 NTSYSAPI
 351 NTSTATUS
 352 NTAPI
 353 RtlCreateRegistryKey(
 354     IN ULONG RelativeTo,
 355     IN PWSTR Path);
 356
 357 NTSYSAPI
 358 NTSTATUS
 359 NTAPI
 360 RtlCreateSecurityDescriptor(
 361     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 362     IN ULONG Revision);
 363
 364 NTSYSAPI
 365 NTSTATUS
 366 NTAPI
 367 RtlDeleteRegistryValue(
 368     IN ULONG RelativeTo,
 369     IN PCWSTR Path,
 370     IN PCWSTR ValueName);
 371
 372 NTSYSAPI
 373 BOOLEAN
 374 NTAPI
 375 RtlEqualUnicodeString(
 376     IN CONST UNICODE_STRING *String1,
 377     IN CONST UNICODE_STRING *String2,
 378     IN BOOLEAN CaseInSensitive);
 379
 380 #if !defined(_AMD64_) && !defined(_IA64_)
 381 NTSYSAPI
 382 LARGE_INTEGER
 383 NTAPI
 384 RtlExtendedIntegerMultiply(
 385     IN LARGE_INTEGER Multiplicand,
 386     IN LONG Multiplier);
 387
 388 NTSYSAPI
 389 LARGE_INTEGER
 390 NTAPI
 391 RtlExtendedLargeIntegerDivide(
 392   IN LARGE_INTEGER Dividend,
 393   IN ULONG Divisor,
 394   IN OUT PULONG Remainder);
 395 #endif
 396
 397 #if defined(_X86_) || defined(_IA64_)
 398 NTSYSAPI
 399 LARGE_INTEGER
 400 NTAPI
 401 RtlExtendedMagicDivide(
 402     IN LARGE_INTEGER Dividend,
 403     IN LARGE_INTEGER MagicDivisor,
 404     IN CCHAR  ShiftCount);
 405 #endif
 406
 407 NTSYSAPI
 408 VOID
 409 NTAPI
 410 RtlFreeAnsiString(
 411     IN PANSI_STRING AnsiString);
 412
 413 NTSYSAPI
 414 ULONG
 415 NTAPI
 416 RtlFindClearBits(
 417     IN PRTL_BITMAP BitMapHeader,
 418     IN ULONG NumberToFind,
 419     IN ULONG HintIndex);
 420
 421 NTSYSAPI
 422 ULONG
 423 NTAPI
 424 RtlFindClearBitsAndSet(
 425     IN PRTL_BITMAP BitMapHeader,
 426     IN ULONG NumberToFind,
 427     IN ULONG HintIndex);
 428
 429 NTSYSAPI
 430 ULONG
 431 NTAPI
 432 RtlFindFirstRunClear(
 433     IN PRTL_BITMAP BitMapHeader,
 434     OUT PULONG StartingIndex);
 435
 436 NTSYSAPI
 437 ULONG
 438 NTAPI
 439 RtlFindClearRuns(
 440     IN PRTL_BITMAP BitMapHeader,
 441     OUT PRTL_BITMAP_RUN RunArray,
 442     IN ULONG SizeOfRunArray,
 443     IN BOOLEAN LocateLongestRuns);
 444
 445 NTSYSAPI
 446 ULONG
 447 NTAPI
 448 RtlFindLastBackwardRunClear(
 449     IN PRTL_BITMAP BitMapHeader,
 450     IN ULONG FromIndex,
 451     OUT PULONG StartingRunIndex);
 452
 453 NTSYSAPI
 454 CCHAR
 455 NTAPI
 456 RtlFindLeastSignificantBit(
 457     IN ULONGLONG Set);
 458
 459 NTSYSAPI
 460 ULONG
 461 NTAPI
 462 RtlFindLongestRunClear(
 463     IN PRTL_BITMAP BitMapHeader,
 464     OUT PULONG StartingIndex);
 465
 466 NTSYSAPI
 467 CCHAR
 468 NTAPI
 469 RtlFindMostSignificantBit(
 470     IN ULONGLONG Set);
 471
 472 NTSYSAPI
 473 ULONG
 474 NTAPI
 475 RtlFindNextForwardRunClear(
 476     IN PRTL_BITMAP BitMapHeader,
 477     IN ULONG FromIndex,
 478     OUT PULONG StartingRunIndex);
 479
 480 NTSYSAPI
 481 ULONG
 482 NTAPI
 483 RtlFindSetBits(
 484     IN PRTL_BITMAP BitMapHeader,
 485     IN ULONG NumberToFind,
 486     IN ULONG HintIndex);
 487
 488 NTSYSAPI
 489 ULONG
 490 NTAPI
 491 RtlFindSetBitsAndClear(
 492     IN PRTL_BITMAP BitMapHeader,
 493     IN ULONG NumberToFind,
 494     IN ULONG HintIndex);
 495
 496 NTSYSAPI
 497 NTSTATUS
 498 NTAPI
 499 RtlHashUnicodeString(
 500     IN CONST UNICODE_STRING *String,
 501     IN BOOLEAN CaseInSensitive,
 502     IN ULONG HashAlgorithm,
 503     OUT PULONG HashValue);
 504
 505 NTSYSAPI
 506 VOID
 507 NTAPI
 508 RtlInitAnsiString(
 509     IN OUT PANSI_STRING DestinationString,
 510     IN PCSZ SourceString);
 511
 512 NTSYSAPI
 513 VOID
 514 NTAPI
 515 RtlInitializeBitMap(
 516     IN PRTL_BITMAP BitMapHeader,
 517     IN PULONG BitMapBuffer,
 518     IN ULONG SizeOfBitMap);
 519
 520 NTSYSAPI
 521 VOID
 522 NTAPI
 523 RtlInitString(
 524     IN OUT PSTRING DestinationString,
 525     IN PCSZ SourceString);
 526
 527 NTSYSAPI
 528 NTSTATUS
 529 NTAPI
 530 RtlIntegerToUnicodeString(
 531     IN ULONG Value,
 532     IN ULONG Base OPTIONAL,
 533     IN OUT PUNICODE_STRING String);
 534
 535 NTSYSAPI
 536 NTSTATUS
 537 NTAPI
 538 RtlInt64ToUnicodeString(
 539     IN ULONGLONG Value,
 540     IN ULONG Base OPTIONAL,
 541     IN OUT PUNICODE_STRING String);
 542
 543 #ifdef _WIN64
 544 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 545     RtlInt64ToUnicodeString(Value, Base, String)
 546 #else
 547 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 548     RtlIntegerToUnicodeString(Value, Base, String)
 549 #endif
 550
 551 /* BOOLEAN
 552  * RtlIsZeroLuid(
 553  *     IN PLUID L1);
 554  */
 555 #define RtlIsZeroLuid(_L1) \
 556     ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
 557
 558 NTSYSAPI
 559 ULONG
 560 NTAPI
 561 RtlLengthSecurityDescriptor(
 562     IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 563
 564 NTSYSAPI
 565 ULONG
 566 NTAPI
 567 RtlNumberOfClearBits(
 568     IN PRTL_BITMAP BitMapHeader);
 569
 570 NTSYSAPI
 571 ULONG
 572 NTAPI
 573 RtlNumberOfSetBits(
 574     IN PRTL_BITMAP BitMapHeader);
 575
 576 NTSYSAPI
 577 NTSTATUS
 578 NTAPI
 579 RtlQueryRegistryValues(
 580     IN ULONG RelativeTo,
 581     IN PCWSTR Path,
 582     IN PRTL_QUERY_REGISTRY_TABLE QueryTable,
 583     IN PVOID Context,
 584     IN PVOID Environment OPTIONAL);
 585
 586 #define LONG_SIZE (sizeof(LONG))
 587 #define LONG_MASK (LONG_SIZE - 1)
 588
 589 /* VOID
 590  * RtlRetrieveUlong(
 591  *        PULONG DestinationAddress,
 592  *        PULONG SourceAddress);
 593  */
 594 #if defined(_AMD64_)
 595 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 596     *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
 597 #else
 598 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 599     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 600     { \
 601         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 602         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 603         ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
 604         ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
 605     } \
 606     else \
 607     { \
 608         *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
 609     }
 610 #endif
 611
 612 /* VOID
 613  * RtlRetrieveUshort(
 614  *        PUSHORT DestinationAddress,
 615  *        PUSHORT SourceAddress);
 616  */
 617 #if defined(_AMD64_)
 618 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 619     *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
 620 #else
 621 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 622     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 623     { \
 624         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 625         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 626     } \
 627     else \
 628     { \
 629         *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
 630     }
 631 #endif
 632
 633 NTSYSAPI
 634 VOID
 635 NTAPI
 636 RtlSetAllBits(
 637     IN PRTL_BITMAP BitMapHeader);
 638
 639 NTSYSAPI
 640 VOID
 641 NTAPI
 642 RtlSetBits(
 643     IN PRTL_BITMAP BitMapHeader,
 644     IN ULONG StartingIndex,
 645     IN ULONG NumberToSet);
 646
 647 NTSYSAPI
 648 NTSTATUS
 649 NTAPI
 650 RtlSetDaclSecurityDescriptor(
 651     IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 652     IN BOOLEAN DaclPresent,
 653     IN PACL Dacl OPTIONAL,
 654     IN BOOLEAN DaclDefaulted OPTIONAL);
 655
 656 /* VOID
 657  * RtlStoreUlong(
 658  *     IN PULONG Address,
 659  *     IN ULONG Value);
 660  */
 661 #if defined(_AMD64_)
 662 #define RtlStoreUlong(Address,Value) \
 663     *(ULONG UNALIGNED *)(Address) = (Value)
 664 #else
 665 #define RtlStoreUlong(Address,Value)                      \
 666     if ((ULONG_PTR)(Address) & LONG_MASK) { \
 667         ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
 668         ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
 669         ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
 670         ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
 671     } \
 672     else { \
 673         *((PULONG)(Address)) = (ULONG) (Value); \
 674     }
 675 #endif
 676
 677 /* VOID
 678  * RtlStoreUlonglong(
 679  *     IN OUT PULONGLONG Address,
 680  *     ULONGLONG Value);
 681  */
 682 #if defined(_AMD64_)
 683 #define RtlStoreUlonglong(Address,Value) \
 684     *(ULONGLONG UNALIGNED *)(Address) = (Value)
 685 #else
 686 #define RtlStoreUlonglong(Address,Value) \
 687     if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
 688         RtlStoreUlong((ULONG_PTR)(Address), \
 689                       (ULONGLONG)(Value) & 0xFFFFFFFF); \
 690         RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
 691                       (ULONGLONG)(Value) >> 32); \
 692     } else { \
 693         *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
 694     }
 695 #endif
 696
 697 /* VOID
 698  * RtlStoreUlongPtr(
 699  *     IN OUT PULONG_PTR Address,
 700  *     IN ULONG_PTR Value);
 701  */
 702 #ifdef _WIN64
 703 #define RtlStoreUlongPtr(Address,Value)                         \
 704     RtlStoreUlonglong(Address,Value)
 705 #else
 706 #define RtlStoreUlongPtr(Address,Value)                         \
 707     RtlStoreUlong(Address,Value)
 708 #endif
 709
 710 /* VOID
 711  * RtlStoreUshort(
 712  *     IN PUSHORT Address,
 713  *     IN USHORT Value);
 714  */
 715 #if defined(_AMD64_)
 716 #define RtlStoreUshort(Address,Value) \
 717     *(USHORT UNALIGNED *)(Address) = (Value)
 718 #else
 719 #define RtlStoreUshort(Address,Value) \
 720     if ((ULONG_PTR)(Address) & SHORT_MASK) { \
 721         ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
 722         ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
 723     } \
 724     else { \
 725         *((PUSHORT) (Address)) = (USHORT)Value; \
 726     }
 727 #endif
 728
 729 NTSYSAPI
 730 BOOLEAN
 731 NTAPI
 732 RtlTimeFieldsToTime(
 733     IN PTIME_FIELDS TimeFields,
 734     IN PLARGE_INTEGER Time);
 735
 736 NTSYSAPI
 737 VOID
 738 NTAPI
 739 RtlTimeToTimeFields(
 740     IN PLARGE_INTEGER Time,
 741     IN PTIME_FIELDS TimeFields);
 742
 743 NTSYSAPI
 744 ULONG
 745 FASTCALL
 746 RtlUlongByteSwap(
 747     IN ULONG Source);
 748
 749 NTSYSAPI
 750 ULONGLONG
 751 FASTCALL
 752 RtlUlonglongByteSwap(
 753     IN ULONGLONG Source);
 754
 755 NTSYSAPI
 756 NTSTATUS
 757 NTAPI
 758 RtlUnicodeStringToAnsiString(
 759     IN OUT PANSI_STRING DestinationString,
 760     IN PCUNICODE_STRING SourceString,
 761     IN BOOLEAN AllocateDestinationString);
 762
 763 NTSYSAPI
 764 ULONG
 765 NTAPI
 766 RtlxUnicodeStringToAnsiSize(
 767     IN PCUNICODE_STRING UnicodeString);
 768
 769 #define RtlUnicodeStringToAnsiSize(String) (                  \
 770     NLS_MB_CODE_PAGE_TAG ?                                    \
 771     RtlxUnicodeStringToAnsiSize(String) :                     \
 772     ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
 773 )
 774
 775 NTSYSAPI
 776 NTSTATUS
 777 NTAPI
 778 RtlUnicodeStringToInteger(
 779     IN PCUNICODE_STRING String,
 780     IN ULONG Base OPTIONAL,
 781     OUT PULONG Value);
 782
 783 NTSYSAPI
 784 WCHAR
 785 NTAPI
 786 RtlUpcaseUnicodeChar(
 787     IN WCHAR SourceCharacter);
 788
 789 NTSYSAPI
 790 USHORT
 791 FASTCALL
 792 RtlUshortByteSwap(
 793     IN USHORT Source);
 794
 795 NTSYSAPI
 796 BOOLEAN
 797 NTAPI
 798 RtlValidRelativeSecurityDescriptor(
 799     IN PSECURITY_DESCRIPTOR SecurityDescriptorInput,
 800     IN ULONG SecurityDescriptorLength,
 801     IN SECURITY_INFORMATION RequiredInformation);
 802
 803 NTSYSAPI
 804 BOOLEAN
 805 NTAPI
 806 RtlValidSecurityDescriptor(
 807     IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 808
 809 NTSYSAPI
 810 NTSTATUS
 811 NTAPI
 812 RtlWriteRegistryValue(
 813     IN ULONG RelativeTo,
 814     IN PCWSTR Path,
 815     IN PCWSTR ValueName,
 816     IN ULONG ValueType,
 817     IN PVOID ValueData,
 818     IN ULONG ValueLength);
 819
 820 #endif // (NTDDI_VERSION >= NTDDI_WIN2K)
 821
 822 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
 823 NTSYSAPI
 824 VOID
 825 FASTCALL
 826 RtlPrefetchMemoryNonTemporal(
 827     IN PVOID Source,
 828     IN SIZE_T Length);
 829 #endif
 830
 831 #if (NTDDI_VERSION >= NTDDI_WINXP)
 832 NTSYSAPI
 833 VOID
 834 NTAPI
 835 RtlClearBit(
 836     PRTL_BITMAP BitMapHeader,
 837     ULONG BitNumber);
 838
 839 NTSYSAPI
 840 WCHAR
 841 NTAPI
 842 RtlDowncaseUnicodeChar(
 843     IN WCHAR SourceCharacter);
 844
 845 NTSYSAPI
 846 VOID
 847 NTAPI
 848 RtlSetBit(
 849     PRTL_BITMAP BitMapHeader,
 850     ULONG BitNumber);
 851
 852 NTSYSAPI
 853 BOOLEAN
 854 NTAPI
 855 RtlTestBit(
 856     IN PRTL_BITMAP BitMapHeader,
 857     IN ULONG BitNumber);
 858
 859 #endif // (NTDDI_VERSION >= NTDDI_WINXP)
 860
 861 #if (NTDDI_VERSION >= NTDDI_VISTA)
 862 NTSYSAPI
 863 ULONG
 864 NTAPI
 865 RtlNumberOfSetBitsUlongPtr(
 866     IN ULONG_PTR Target);
 867
 868 NTSYSAPI
 869 ULONGLONG
 870 NTAPI
 871 RtlIoDecodeMemIoResource (
 872     IN struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
 873     OUT PULONGLONG Alignment OPTIONAL,
 874     OUT PULONGLONG MinimumAddress OPTIONAL,
 875     OUT PULONGLONG MaximumAddress OPTIONAL);
 876
 877 NTSYSAPI
 878 NTSTATUS
 879 NTAPI
 880 RtlIoEncodeMemIoResource(
 881     IN struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
 882     IN UCHAR Type,
 883     IN ULONGLONG Length,
 884     IN ULONGLONG Alignment,
 885     IN ULONGLONG MinimumAddress,
 886     IN ULONGLONG MaximumAddress);
 887
 888 NTSYSAPI
 889 ULONGLONG
 890 NTAPI
 891 RtlCmDecodeMemIoResource(
 892     IN struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
 893     OUT PULONGLONG Start OPTIONAL);
 894
 895 NTSYSAPI
 896 NTSTATUS
 897 NTAPI
 898 RtlFindClosestEncodableLength(
 899     IN ULONGLONG SourceLength,
 900     OUT PULONGLONG TargetLength);
 901
 902 #endif
 903
 904 #if !defined(MIDL_PASS)
 905 /* inline funftions */
 906 //DECLSPEC_DEPRECATED_DDK_WINXP
 907 static __inline
 908 LARGE_INTEGER
 909 NTAPI_INLINE
 910 RtlConvertLongToLargeInteger(LONG SignedInteger)
 911 {
 912     LARGE_INTEGER ret;
 913     ret.QuadPart = SignedInteger;
 914     return ret;
 915 }
 916
 917 //DECLSPEC_DEPRECATED_DDK_WINXP
 918 static __inline
 919 LARGE_INTEGER
 920 NTAPI_INLINE
 921 RtlConvertUlongToLargeInteger(
 922   ULONG UnsignedInteger)
 923 {
 924     LARGE_INTEGER ret;
 925     ret.QuadPart = UnsignedInteger;
 926     return ret;
 927 }
 928
 929 //DECLSPEC_DEPRECATED_DDK
 930 static __inline
 931 ULONG
 932 NTAPI_INLINE
 933 RtlEnlargedUnsignedDivide(
 934     IN ULARGE_INTEGER Dividend,
 935     IN ULONG Divisor,
 936     IN OUT PULONG Remainder)
 937 {
 938     if (Remainder)
 939         *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
 940     return (ULONG)(Dividend.QuadPart / Divisor);
 941 }
 942
 943 //DECLSPEC_DEPRECATED_DDK
 944 static __inline
 945 LARGE_INTEGER
 946 NTAPI_INLINE
 947 RtlEnlargedUnsignedMultiply(
 948     IN ULONG Multiplicand,
 949     IN ULONG Multiplier)
 950 {
 951     LARGE_INTEGER ret;
 952     ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
 953     return ret;
 954 }
 955
 956 //DECLSPEC_DEPRECATED_DDK
 957 static __inline
 958 LARGE_INTEGER
 959 NTAPI_INLINE
 960 RtlEnlargedIntegerMultiply(
 961     IN LONG Multiplicand,
 962     IN LONG Multiplier)
 963 {
 964     LARGE_INTEGER ret;
 965     ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
 966     return ret;
 967 }
 968
 969 FORCEINLINE
 970 VOID
 971 RtlInitEmptyAnsiString(OUT PANSI_STRING AnsiString,
 972                        IN PCHAR Buffer,
 973                        IN USHORT BufferSize)
 974 {
 975     AnsiString->Length = 0;
 976     AnsiString->MaximumLength = BufferSize;
 977     AnsiString->Buffer = Buffer;
 978 }
 979
 980 FORCEINLINE
 981 VOID
 982 RtlInitEmptyUnicodeString(
 983     OUT PUNICODE_STRING UnicodeString,
 984     IN PWSTR Buffer,
 985     IN USHORT BufferSize)
 986 {
 987     UnicodeString->Length = 0;
 988     UnicodeString->MaximumLength = BufferSize;
 989     UnicodeString->Buffer = Buffer;
 990 }
 991
 992 #if defined(_AMD64_) || defined(_IA64_)
 993 static __inline
 994 LARGE_INTEGER
 995 NTAPI_INLINE
 996 RtlExtendedIntegerMultiply(
 997     LARGE_INTEGER Multiplicand,
 998     LONG Multiplier)
 999 {
1000     LARGE_INTEGER ret;
1001     ret.QuadPart = Multiplicand.QuadPart * Multiplier;
1002     return ret;
1003 }
1004
1005 static __inline
1006 LARGE_INTEGER
1007 NTAPI_INLINE
1008 RtlExtendedLargeIntegerDivide(
1009     LARGE_INTEGER Dividend,
1010     ULONG Divisor,
1011     PULONG Remainder)
1012 {
1013     LARGE_INTEGER ret;
1014     ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
1015     if (Remainder)
1016         *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
1017     return ret;
1018 }
1019 #endif
1020
1021 #if defined(_AMD64_)
1022
1023 #define MultiplyHigh __mulh
1024 #define UnsignedMultiplyHigh __umulh
1025
1026 //DECLSPEC_DEPRECATED_DDK
1027 static __inline
1028 LARGE_INTEGER
1029 NTAPI_INLINE
1030 RtlExtendedMagicDivide(
1031     IN LARGE_INTEGER Dividend,
1032     IN LARGE_INTEGER MagicDivisor,
1033     IN CCHAR ShiftCount)
1034 {
1035     LARGE_INTEGER ret;
1036     ULONG64 ret64;
1037     BOOLEAN Pos;
1038     Pos = (Dividend.QuadPart >= 0);
1039     ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
1040                                  MagicDivisor.QuadPart);
1041     ret64 >>= ShiftCount;
1042     ret.QuadPart = Pos ? ret64 : -ret64;
1043     return ret;
1044 }
1045 #endif
1046
1047 //DECLSPEC_DEPRECATED_DDK
1048 static __inline
1049 LARGE_INTEGER
1050 NTAPI_INLINE
1051 RtlLargeIntegerAdd(
1052     IN LARGE_INTEGER Addend1,
1053     IN LARGE_INTEGER Addend2)
1054 {
1055     LARGE_INTEGER ret;
1056     ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
1057     return ret;
1058 }
1059
1060 /* VOID
1061  * RtlLargeIntegerAnd(
1062  *     IN OUT LARGE_INTEGER Result,
1063  *     IN LARGE_INTEGER Source,
1064  *     IN LARGE_INTEGER Mask);
1065  */
1066 #define RtlLargeIntegerAnd(Result, Source, Mask) \
1067     Result.QuadPart = Source.QuadPart & Mask.QuadPart
1068
1069 //DECLSPEC_DEPRECATED_DDK
1070 static __inline
1071 LARGE_INTEGER
1072 NTAPI_INLINE
1073 RtlLargeIntegerArithmeticShift(
1074     IN LARGE_INTEGER LargeInteger,
1075     IN CCHAR ShiftCount)
1076 {
1077     LARGE_INTEGER ret;
1078     ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
1079     return ret;
1080 }
1081
1082 /* BOOLEAN
1083  * RtlLargeIntegerEqualTo(
1084  *     IN LARGE_INTEGER  Operand1,
1085  *     IN LARGE_INTEGER  Operand2);
1086  */
1087 #define RtlLargeIntegerEqualTo(X,Y) \
1088     (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1089
1090 FORCEINLINE
1091 PVOID
1092 RtlSecureZeroMemory(
1093     OUT PVOID Pointer,
1094     IN SIZE_T Size)
1095 {
1096     volatile char* vptr = (volatile char*)Pointer;
1097 #if defined(_M_AMD64)
1098     __stosb((PUCHAR)vptr, 0, Size);
1099 #else
1100     char * endptr = (char *)vptr + Size;
1101     while (vptr < endptr)
1102     {
1103         *vptr = 0; vptr++;
1104     }
1105 #endif
1106      return Pointer;
1107 }
1108
1109 #if defined(_M_AMD64)
1110 FORCEINLINE
1111 ULONG
1112 RtlCheckBit(
1113     IN PRTL_BITMAP BitMapHeader,
1114     IN ULONG BitPosition)
1115 {
1116     return BitTest((LONG CONST*)BitMapHeader->Buffer, BitPosition);
1117 }
1118 #else
1119 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
1120 #endif // defined(_M_AMD64)
1121
1122 #endif // !defined(MIDL_PASS)
1123
1124 /* Byte Swap Functions */
1125 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
1126     ((defined(_M_AMD64) || defined(_M_IA64)) \
1127         && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
1128
1129 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
1130 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
1131 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
1132
1133 #endif
1134
1135 #if DBG
1136
1137 #define ASSERT(exp) \
1138   (VOID)((!(exp)) ? \
1139     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
1140
1141 #define ASSERTMSG(msg, exp) \
1142   (VOID)((!(exp)) ? \
1143     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, msg ), FALSE : TRUE)
1144
1145 #define RTL_SOFT_ASSERT(exp) \
1146   (VOID)((!(exp)) ? \
1147     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
1148
1149 #define RTL_SOFT_ASSERTMSG(msg, exp) \
1150   (VOID)((!(exp)) ? \
1151     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n   Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
1152
1153 #define RTL_VERIFY(exp) ASSERT(exp)
1154 #define RTL_VERIFYMSG(msg, exp) ASSERTMSG(msg, exp)
1155
1156 #define RTL_SOFT_VERIFY(exp) RTL_SOFT_ASSERT(exp)
1157 #define RTL_SOFT_VERIFYMSG(msg, exp) RTL_SOFT_ASSERTMSG(msg, exp)
1158
1159 #if defined(_MSC_VER)
1160
1161 #define NT_ASSERT(exp) \
1162    ((!(exp)) ? \
1163       (__annotation(L"Debug", L"AssertFail", L#exp), \
1164        DbgRaiseAssertionFailure(), FALSE) : TRUE)
1165
1166 #define NT_ASSERTMSG(msg, exp) \
1167    ((!(exp)) ? \
1168       (__annotation(L"Debug", L"AssertFail", L##msg), \
1169       DbgRaiseAssertionFailure(), FALSE) : TRUE)
1170
1171 #define NT_ASSERTMSGW(msg, exp) \
1172     ((!(exp)) ? \
1173         (__annotation(L"Debug", L"AssertFail", msg), \
1174          DbgRaiseAssertionFailure(), FALSE) : TRUE)
1175
1176 #else
1177
1178 /* GCC doesn't support __annotation (nor PDB) */
1179 #define NT_ASSERT(exp) \
1180    (VOID)((!(exp)) ? (DbgRaiseAssertionFailure(), FALSE) : TRUE)
1181
1182 #define NT_ASSERTMSG NT_ASSERT
1183 #define NT_ASSERTMSGW NT_ASSERT
1184
1185 #endif
1186
1187 #else /* !DBG */
1188
1189 #define ASSERT(exp) ((VOID) 0)
1190 #define ASSERTMSG(msg, exp) ((VOID) 0)
1191
1192 #define RTL_SOFT_ASSERT(exp) ((VOID) 0)
1193 #define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
1194
1195 #define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
1196 #define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
1197
1198 #define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
1199 #define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
1200
1201 #define NT_ASSERT(exp)     ((VOID)0)
1202 #define NT_ASSERTMSG(exp)  ((VOID)0)
1203 #define NT_ASSERTMSGW(exp) ((VOID)0)
1204
1205 #endif /* DBG */
1206
1207 #if !defined(_WINBASE_)
1208
1209 #if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
1210
1211 NTKERNELAPI
1212 VOID
1213 InitializeSListHead(
1214   OUT PSLIST_HEADER SListHead);
1215
1216 #else
1217
1218 VOID
1219 FORCEINLINE
1220 InitializeSListHead(
1221   OUT PSLIST_HEADER SListHead)
1222 {
1223 #if defined(_IA64_)
1224     ULONG64 FeatureBits;
1225 #endif
1226
1227 #if defined(_WIN64)
1228     if (((ULONG_PTR)SListHead & 0xf) != 0)
1229     {
1230         RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
1231     }
1232 #endif
1233
1234     RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
1235
1236 #if defined(_IA64_)
1237     FeatureBits = __getReg(CV_IA64_CPUID4);
1238     if ((FeatureBits & KF_16BYTE_INSTR) != 0)
1239     {
1240         SListHead->Header16.HeaderType = 1;
1241         SListHead->Header16.Init = 1;
1242     }
1243 #endif
1244 }
1245
1246 #endif
1247
1248 #if defined(_WIN64)
1249
1250 #define InterlockedPopEntrySList(Head) \
1251     ExpInterlockedPopEntrySList(Head)
1252
1253 #define InterlockedPushEntrySList(Head, Entry) \
1254     ExpInterlockedPushEntrySList(Head, Entry)
1255
1256 #define InterlockedFlushSList(Head) \
1257     ExpInterlockedFlushSList(Head)
1258
1259 #define QueryDepthSList(Head) \
1260     ExQueryDepthSList(Head)
1261
1262 #else /* !defined(_WIN64) */
1263
1264 NTKERNELAPI
1265 PSLIST_ENTRY
1266 FASTCALL
1267 InterlockedPopEntrySList(
1268     IN PSLIST_HEADER ListHead);
1269
1270 NTKERNELAPI
1271 PSLIST_ENTRY
1272 FASTCALL
1273 InterlockedPushEntrySList(
1274     IN PSLIST_HEADER ListHead,
1275     IN PSLIST_ENTRY ListEntry);
1276
1277 #define InterlockedFlushSList(ListHead) \
1278     ExInterlockedFlushSList(ListHead)
1279
1280 #define QueryDepthSList(Head) \
1281     ExQueryDepthSList(Head)
1282
1283 #endif /* !defined(_WIN64) */
1284
1285 #endif /* !defined(_WINBASE_) */
1286